home *** CD-ROM | disk | FTP | other *** search
/ The Atari Compendium / The Atari Compendium (Toad Computers) (1994).iso / files / prgtools / gnustuff / tos / updates / update29.zoo / gprof / diffs
Encoding:
Text File  |  1993-03-28  |  27.1 KB  |  1,134 lines
  1. ===================================================================
  2. RCS file: /net/acae127/home/bammi/etc/src/master/atari/gprof/Changelog,v
  3. retrieving revision 1.11
  4. diff -c -r1.11 Changelog
  5. *** 1.11    1992/08/14 17:19:16
  6. --- Changelog    1993/03/29 03:36:26
  7. ***************
  8. *** 72,74 ****
  9. --- 72,81 ----
  10.       clean up binary seach conditions in val_to_sym.
  11.   
  12.   ------------------------------- Patchlevel 9 ---------------------------
  13. + 
  14. + gprof.c: andreas
  15. +     Handle both st-out and gnu-out (from sym-ld) format.
  16. + 
  17. + cplusdem.c: andreas
  18. +     update
  19. + ------------------------------- Patchlevel 10 ---------------------------
  20. ===================================================================
  21. RCS file: /net/acae127/home/bammi/etc/src/master/atari/gprof/PatchLev.h,v
  22. retrieving revision 1.11
  23. diff -c -r1.11 PatchLev.h
  24. *** 1.11    1992/08/14 17:19:16
  25. --- PatchLev.h    1993/03/29 03:36:27
  26. ***************
  27. *** 1,4 ****
  28. ! #define    PatchLevel "09"
  29.   
  30.   /*
  31.    *    the Patch Level above is to identify the version
  32. --- 1,4 ----
  33. ! #define    PatchLevel "10"
  34.   
  35.   /*
  36.    *    the Patch Level above is to identify the version
  37. ===================================================================
  38. RCS file: /net/acae127/home/bammi/etc/src/master/atari/gprof/cplusdem.c,v
  39. retrieving revision 1.3
  40. diff -c -r1.3 cplusdem.c
  41. *** 1.3    1992/06/11 17:51:35
  42. --- cplusdem.c    1993/03/29 03:36:30
  43. ***************
  44. *** 23,29 ****
  45.   
  46.      Modified for g++ 1.90.06 (December 31 version).
  47.   
  48. !    Modified for g++ 1.95.03 (November 13 verison).  */
  49.   
  50.   /* This file exports one function
  51.   
  52. --- 23,29 ----
  53.   
  54.      Modified for g++ 1.90.06 (December 31 version).
  55.   
  56. !    Modified for g++ 1.95.03 (November 13 version).  */
  57.   
  58.   /* This file exports one function
  59.   
  60. ***************
  61. *** 148,154 ****
  62.     "co", "~",            /* ansi */
  63.     "call", "()",            /* old */
  64.     "cl", "()",            /* ansi */
  65. -   "cond", "?:",            /* old */
  66.     "alshift", "<<",        /* old */
  67.     "ls", "<<",            /* ansi */
  68.     "als", "<<=",            /* ansi */
  69. --- 148,153 ----
  70. ***************
  71. *** 172,177 ****
  72. --- 171,177 ----
  73.     "mx", ">?",            /* psuedo-ansi */
  74.     "min", "<?",            /* old */
  75.     "mn", "<?",            /* psuedo-ansi */
  76. +   "rm", "->*",            /* ansi */
  77.   };
  78.   
  79.   /* Beware: these aren't '\0' terminated. */
  80. ***************
  81. *** 235,240 ****
  82. --- 235,242 ----
  83.   {
  84.     int n = 0, success = 1;;
  85.     
  86. +   if (!isdigit (**type))
  87. +     return 0;
  88.     do
  89.       {
  90.         n *= 10;
  91. ***************
  92. *** 274,292 ****
  93.     if (*type++ != '_')
  94.       return NULL;
  95.   #endif
  96. !   p = type;
  97. !   while (*p != '\0' && !(*p == '_' && p[1] == '_'))
  98. !     p++;
  99. !   if (*p == '\0')
  100.       {
  101. !       /* destructor */
  102. !       if (type[0] == '_' && type[1] == CPLUS_MARKER && type[2] == '_')
  103.       {
  104. !       destructor = 1;
  105. !       p = type;
  106.       }
  107. !       /* virtual table "_vt$"  */
  108. !       else if (type[0] == '_' && type[1] == 'v' && type[2] == 't' && type[3] == CPLUS_MARKER)
  109.       {
  110.         int n = strlen (type + 4) + 14 + 1;
  111.         char *tem = (char *) xmalloc (n);
  112. --- 276,312 ----
  113.     if (*type++ != '_')
  114.       return NULL;
  115.   #endif
  116. !   /* destructor */
  117. !   if (type[0] == '_' && type[1] == CPLUS_MARKER && type[2] == '_')
  118. !     {
  119. !       destructor = 1;
  120. !       p = type;
  121. !     }
  122. !   /* virtual table "_vt$"  */
  123. !   else if (type[0] == '_' && type[1] == 'v' && type[2] == 't' && type[3] == CPLUS_MARKER)
  124.       {
  125. !       if (isdigit (type[4]))
  126.       {
  127. !       int n;
  128. !       string_init (&decl);
  129. !       type += 4;
  130. !       while (get_simple_count (&type, &n))
  131. !         {
  132. !           string_appendn (&decl, type, n);
  133. !           type += n;
  134. !           if (*type == '\0')
  135. !         {
  136. !           string_appendn (&decl, " virtual table", 15);
  137. !           return decl.b;
  138. !         }
  139. !           if (*type++ != CPLUS_MARKER)
  140. !         break;
  141. !           string_append (&decl, "::");
  142. !         }
  143. !       string_delete (&decl);
  144. !       return NULL;
  145.       }
  146. !       else
  147.       {
  148.         int n = strlen (type + 4) + 14 + 1;
  149.         char *tem = (char *) xmalloc (n);
  150. ***************
  151. *** 294,313 ****
  152.         strcat (tem, " virtual table");
  153.         return tem;
  154.       }
  155. !       /* static data member */
  156. !       else if (type[0] == '_' && type[1] != '_' && (strchr (type, CPLUS_MARKER) != NULL))
  157. !     {
  158. !       static_type = 1;
  159. !       p = type + 1;
  160. !     }
  161. !       else return NULL;
  162.       }
  163.   
  164.     string_init (&decl);
  165.   
  166.     if (static_type)
  167.       {
  168. !       if (!isdigit (p[0]) && ('t' != p[0]))
  169.       {
  170.         string_delete (&decl);
  171.         return NULL;
  172. --- 314,341 ----
  173.         strcat (tem, " virtual table");
  174.         return tem;
  175.       }
  176. !     }
  177. !   /* static data member */
  178. !   else if (type[0] == '_' && strchr ("0123456789Qt", type[1] != '_') != NULL
  179. !        && strchr (type, CPLUS_MARKER) != NULL)
  180. !     {
  181. !       static_type = 1;
  182. !       p = type + 1;
  183.       }
  184. +   else
  185. +     {
  186. +       p = type;
  187. +       while (*p != '\0' && !(*p == '_' && p[1] == '_'))
  188. +     p++;
  189. +       if (*p == '\0')
  190. +     return NULL;
  191. +     }
  192.   
  193.     string_init (&decl);
  194.   
  195.     if (static_type)
  196.       {
  197. !       if (!isdigit (p[0]) && ('t' != p[0]) && p[0] != 'Q')
  198.       {
  199.         string_delete (&decl);
  200.         return NULL;
  201. ***************
  202. *** 315,321 ****
  203.       }
  204.     else if (destructor)
  205.       {
  206. !       if (!isdigit (p[3])&& ('t' != p[3]))
  207.       {
  208.         string_delete (&decl);
  209.         return NULL;
  210. --- 343,349 ----
  211.       }
  212.     else if (destructor)
  213.       {
  214. !       if (!isdigit (p[3])&& ('t' != p[3]) && p[3] != 'Q')
  215.       {
  216.         string_delete (&decl);
  217.         return NULL;
  218. ***************
  219. *** 324,330 ****
  220.       }
  221.     else if (p == type)
  222.       {
  223. !       if (!isdigit (p[2]) && ('t' != p[2]))
  224.       {
  225.         p += 1;
  226.         while (*p != '\0' && !(*p == '_' && p[1] == '_'))
  227. --- 352,358 ----
  228.       }
  229.     else if (p == type)
  230.       {
  231. !       if (!isdigit (p[2]) && ('t' != p[2]) && p[2] != 'Q')
  232.       {
  233.         p += 1;
  234.         while (*p != '\0' && !(*p == '_' && p[1] == '_'))
  235. ***************
  236. *** 345,351 ****
  237.     else
  238.       {
  239.         string_appendn (&decl, type, p - type);
  240. !       decl.p[0] = '0';
  241.         munge_function_name (&decl);
  242.         p += 2;
  243.       }
  244. --- 373,379 ----
  245.     else
  246.       {
  247.         string_appendn (&decl, type, p - type);
  248. !       decl.p[0] = '\0';
  249.         munge_function_name (&decl);
  250.         p += 2;
  251.       }
  252. ***************
  253. *** 451,456 ****
  254. --- 479,486 ----
  255.           string_delete (&trawname);
  256.           break;
  257.         }
  258. +     if (tname.p[-1] == '>')
  259. +       string_append (&tname, " ");
  260.       string_append (&tname, ">::");
  261.       if (destructor)
  262.         string_append(&tname, "~");
  263. ***************
  264. *** 556,573 ****
  265.         int member;
  266.         switch (**type)
  267.       {
  268. -     case 'Q':
  269. -       n = (*type)[1] - '0';
  270. -       if (n < 0 || n > 9)
  271. -         {
  272. -           success = 0;
  273. -           break;
  274. -         }
  275. -       *type += 2;
  276. -       while (n-- > 0)
  277. -         do_type (type, result);
  278. -       break;
  279. - 
  280.       case 'P':
  281.         *type += 1;
  282.         string_prepend (&decl, "*");
  283. --- 586,591 ----
  284. ***************
  285. *** 610,629 ****
  286.   
  287.           member = **type == 'M';
  288.           *type += 1;
  289. !         if (!isdigit (**type))
  290. !           {
  291. !         success = 0;
  292. !         break;
  293. !           }
  294. !         n = 0;
  295. !         do
  296. !           {
  297. !         n *= 10;
  298. !         n += **type - '0';
  299. !         *type += 1;
  300. !           } 
  301. !         while (isdigit (**type));
  302. !         if (strlen (*type) < n)
  303.             {
  304.           success = 0;
  305.           break;
  306. --- 628,634 ----
  307.   
  308.           member = **type == 'M';
  309.           *type += 1;
  310. !         if (!get_simple_count (type, &n))
  311.             {
  312.           success = 0;
  313.           break;
  314. ***************
  315. *** 747,752 ****
  316. --- 752,765 ----
  317.           *non_empty = 1;
  318.         string_append (result, "unsigned");
  319.         break;
  320. +     case 'S':
  321. +       *type += 1;
  322. +       if (*non_empty)
  323. +         string_append (result, " ");
  324. +       else
  325. +         *non_empty = 1;
  326. +       string_append (result, "signed");
  327. +       break;
  328.       case 'V':
  329.         *type += 1;
  330.         if (*non_empty)
  331. ***************
  332. *** 813,818 ****
  333. --- 826,837 ----
  334.       string_append (result, " ");
  335.         string_append (result, "char");
  336.         break;
  337. +     case 'w':
  338. +       *type += 1;
  339. +       if (*non_empty)
  340. +     string_append (result, " ");
  341. +       string_append (result, "wchar_t");
  342. +       break;
  343.       case 'r':
  344.         *type += 1;
  345.         if (*non_empty)
  346. ***************
  347. *** 883,890 ****
  348.         if (!do_template_args (type, result))
  349.       success = 0;
  350.         else
  351. !     string_append (result, ">");
  352.         break;
  353.       default:
  354.         success = 0;
  355.         break;
  356. --- 902,947 ----
  357.         if (!do_template_args (type, result))
  358.       success = 0;
  359.         else
  360. !     {
  361. !       if (result->p[-1] == '>')
  362. !         string_append (result, " ");
  363. !       string_append (result, ">");
  364. !     }
  365. !       break;
  366. !     case 'Q':
  367. !       n = (*type)[1] - '0';
  368. !       if (n < 0 || n > 9)
  369. !     {
  370. !       success = 0;
  371. !       break;
  372. !     }
  373. !       *type += 2;
  374. !       if (n > 0)
  375. !     {
  376. !       string temp;
  377. !       if (!do_type (type, &temp))
  378. !         {
  379. !           success = 0;
  380. !           break;
  381. !         }
  382. !       if (*non_empty)
  383. !         string_append (result, " ");
  384. !       string_appends (result, &temp);
  385. !       string_delete (&temp);
  386. !       while (--n > 0)
  387. !         {
  388. !           if (!do_type (type, &temp))
  389. !         {
  390. !           success = 0;
  391. !           break;
  392. !         }
  393. !           string_append (result, "::");
  394. !           string_appends (result, &temp);
  395. !           string_delete (&temp);
  396. !         }
  397. !     }
  398.         break;
  399. +       
  400.       default:
  401.         success = 0;
  402.         break;
  403. ***************
  404. *** 916,922 ****
  405.       {
  406.         *type += 1;
  407.   
  408. !       success = do_type (type, &temp);
  409.         if (success)
  410.           string_appends (result, &temp);
  411.         string_delete(&temp);
  412. --- 973,979 ----
  413.       {
  414.         *type += 1;
  415.   
  416. !       success = do_arg (type, &temp);
  417.         if (success)
  418.           string_appends (result, &temp);
  419.         string_delete(&temp);
  420. ***************
  421. *** 932,938 ****
  422.         int is_integral = 0;
  423.         int done = 0;
  424.   
  425. !       success = do_type (type, &temp);
  426.         if (success)
  427.           string_appends (result, &temp);
  428.         string_delete(&temp);
  429. --- 989,995 ----
  430.         int is_integral = 0;
  431.         int done = 0;
  432.   
  433. !       success = do_arg (type, &temp);
  434.         if (success)
  435.           string_appends (result, &temp);
  436.         string_delete(&temp);
  437. ***************
  438. *** 948,953 ****
  439. --- 1005,1011 ----
  440.             done = is_pointer = 1;
  441.             break;
  442.           case 'C':    /* const */
  443. +         case 'S':    /* explicitly signed [char] */
  444.           case 'U':    /* unsigned */
  445.           case 'V':    /* volatile */
  446.           case 'F':    /* function */
  447. ***************
  448. *** 967,972 ****
  449. --- 1025,1031 ----
  450.           case 'i':    /* int */
  451.           case 's':    /* short */
  452.           case 'c':    /* char */
  453. +         case 'w':    /* wchar_t */
  454.             done = is_integral = 1;
  455.             break;
  456.           case 'r':    /* long double */
  457. ***************
  458. *** 1039,1046 ****
  459.       }
  460.         need_comma = 1;
  461.       }
  462. !     return success;
  463. ! 
  464.   }
  465.   
  466.   /* `result' will be initialised in do_type; it will be freed on failure */
  467. --- 1098,1104 ----
  468.       }
  469.         need_comma = 1;
  470.       }
  471. !   return success;
  472.   }
  473.   
  474.   /* `result' will be initialised in do_type; it will be freed on failure */
  475. ===================================================================
  476. RCS file: /net/acae127/home/bammi/etc/src/master/atari/gprof/gprof.c,v
  477. retrieving revision 1.9
  478. diff -c -r1.9 gprof.c
  479. *** 1.9    1992/08/14 17:19:16
  480. --- gprof.c    1993/03/29 03:36:31
  481. ***************
  482. *** 49,54 ****
  483. --- 49,56 ----
  484.   
  485.   #ifdef atarist
  486.   #    include <st-out.h>
  487. + #    include <gnu-out.h>
  488. + #    define A_OUT
  489.   #else
  490.   #  if !defined(A_OUT) && !defined(MACH_O)
  491.   #    define A_OUT
  492. ***************
  493. *** 412,424 ****
  494.   /* argv[0], here for the sake of error messages.  */
  495.   char *myname = 0;
  496.   
  497. - /* Header of the executable file.  */
  498. - #ifdef atarist
  499. - struct aexec exec_header;
  500. - #else
  501. - struct exec exec_header;
  502. - #endif
  503. - 
  504.   /* Name of the executable file.  */
  505.   char *exec_file_name;
  506.   
  507. --- 414,419 ----
  508. ***************
  509. *** 429,439 ****
  510.   char *strs;
  511.   
  512.   #ifdef atarist
  513. ! /* The maximal length of an symbol name.
  514. !    This is initially eight, but will be changed to 22 in the code
  515.      if any GST compatible long symbols are detected in the symbol table.
  516.      NOTE: do not change it manually here */
  517. ! int max_atari_sym_length = 8;
  518.   #endif
  519.   
  520.   /* Header of the first gmon.out file we read.  This is used to (try to)
  521. --- 424,440 ----
  522.   char *strs;
  523.   
  524.   #ifdef atarist
  525. ! /* The maximal length of an symbol name (without leading underscore).
  526. !    This is initially seven, but will be changed to 21 in the code
  527.      if any GST compatible long symbols are detected in the symbol table.
  528.      NOTE: do not change it manually here */
  529. ! int max_atari_sym_length = 7;
  530. ! 
  531. ! /* The format of the exec file.
  532. !    This is set to FALSE, if the exec file is in gnu-out format as produced
  533. !    by sym-ld.  It is checked when comparing symbols, which have limited
  534. !    length in the st-out format. */
  535. ! int atari_exec_format = TRUE;
  536.   #endif
  537.   
  538.   /* Header of the first gmon.out file we read.  This is used to (try to)
  539. ***************
  540. *** 634,642 ****
  541.   /* Prototypes for all the functions.  */
  542.   
  543.   int    main EXT2(int, char **);
  544. - #ifndef atarist
  545.   int    read_header_info EXT6 (char *, FILE *, long int *, unsigned int *,
  546.                      long int *, unsigned int *);
  547.   #endif
  548.   void    print_flat_profile EXT0();
  549.   void    print_call_graph EXT0();
  550. --- 635,645 ----
  551.   /* Prototypes for all the functions.  */
  552.   
  553.   int    main EXT2(int, char **);
  554.   int    read_header_info EXT6 (char *, FILE *, long int *, unsigned int *,
  555.                      long int *, unsigned int *);
  556. + #ifdef atarist
  557. + int    atari_read_header_info EXT4 (char *, FILE *, long int *,
  558. +                      unsigned int *);
  559.   #endif
  560.   void    print_flat_profile EXT0();
  561.   void    print_call_graph EXT0();
  562. ***************
  563. *** 653,663 ****
  564.   struct mesym **find_funp_from_name EXT1(char *);
  565.   struct mesym **find_funp_from_pointer EXT1(struct mesym *);
  566.   void    read_syms EXT2(FILE *, int);
  567.   struct mesym *val_to_sym EXT1(unsigned long);
  568. - #ifndef atarist
  569.   int    badsym EXT1(struct nlist *);
  570. ! #else
  571. ! int    badsym EXT1(struct asym *);
  572.   #endif
  573.   int    symcmp EXT2(const void *, const void *);
  574.   int    timecmp EXT2(const void *, const void *);
  575. --- 656,668 ----
  576.   struct mesym **find_funp_from_name EXT1(char *);
  577.   struct mesym **find_funp_from_pointer EXT1(struct mesym *);
  578.   void    read_syms EXT2(FILE *, int);
  579. + #ifdef atarist
  580. + void    atari_read_syms EXT2(FILE *, int);
  581. + #endif
  582.   struct mesym *val_to_sym EXT1(unsigned long);
  583.   int    badsym EXT1(struct nlist *);
  584. ! #ifdef atarist
  585. ! int    atari_badsym EXT1(struct asym *);
  586.   #endif
  587.   int    symcmp EXT2(const void *, const void *);
  588.   int    timecmp EXT2(const void *, const void *);
  589. ***************
  590. *** 752,758 ****
  591.     int    argc;
  592.     char    **argv;
  593.     int    c;
  594. -   int n;
  595.   
  596.     extern char *optarg;
  597.     extern int optind, opterr;
  598. --- 757,762 ----
  599. ***************
  600. *** 776,790 ****
  601.        
  602.     char *name = '\0';
  603.     int    ind;  
  604. - #ifndef atarist
  605.     long int syms_offset;
  606.     unsigned int syms_size;
  607.     long int strs_offset;
  608.     unsigned int strs_size;
  609. - #endif
  610.   
  611.   #ifdef atarist
  612. !   _malloczero(1);
  613.   #endif
  614.     argc=ac;
  615.     argv=av;
  616. --- 780,792 ----
  617.        
  618.     char *name = '\0';
  619.     int    ind;  
  620.     long int syms_offset;
  621.     unsigned int syms_size;
  622.     long int strs_offset;
  623.     unsigned int strs_size;
  624.   
  625.   #ifdef atarist
  626. !   /* _malloczero(1); */
  627.   #endif
  628.     argc=ac;
  629.     argv=av;
  630. ***************
  631. *** 870,894 ****
  632.     /* Open the a.out file, and read in selected portions */
  633.   #ifdef atarist
  634.     fp=ck_fopen (exec_file_name, "rb");
  635. !   ck_fread ((void *)&exec_header, sizeof (exec_header), 1, fp);
  636. ! 
  637. !   /* Make sure its really an a.out file.  If it isn't yell and scream
  638. !      and stamp our feet. */
  639. !   if (A_BADMAG (exec_header))
  640. !     fatal ("`%s' is not an executable file", exec_file_name);
  641. ! 
  642. !   if(exec_header.a_syms == 0L)
  643. !     fatal ("`%s' has no symbols", exec_file_name);
  644. ! 
  645. !   /* Read the symbols, and put the interesting ones (sorted) in SYMS.  */
  646. !   /* read_syms builds strs too */
  647. !   ck_fseek (fp, A_SYMOFF (exec_header), 0);
  648. !   read_syms (fp, exec_header.a_syms/sizeof (struct asym));
  649. ! 
  650. ! #else /* ! atarist */
  651. ! 
  652. !   /* Open the a.out file, and read in selected portions */
  653.     fp=ck_fopen (exec_file_name, "r");
  654.   
  655.     /* Make sure its really an a.out file.  If it isn't yell and scream
  656.        and stamp our feet. */
  657. --- 872,893 ----
  658.     /* Open the a.out file, and read in selected portions */
  659.   #ifdef atarist
  660.     fp=ck_fopen (exec_file_name, "rb");
  661. ! #else
  662.     fp=ck_fopen (exec_file_name, "r");
  663. + #endif
  664. + 
  665. + #ifdef atarist
  666. +   if (atari_read_header_info (exec_file_name, fp, &syms_offset, &syms_size))
  667. +     {
  668. +       /* Read the symbols, and put the interesting ones (sorted) in SYMS.  */
  669. +       /* read_syms builds strs too */
  670. +       ck_fseek (fp, syms_offset, 0);
  671. +       atari_read_syms (fp, syms_size / sizeof (struct asym));
  672. +     }
  673. +   else
  674. +     {
  675. +       atari_exec_format = FALSE;
  676. + #endif /* atarist */
  677.   
  678.     /* Make sure its really an a.out file.  If it isn't yell and scream
  679.        and stamp our feet. */
  680. ***************
  681. *** 903,908 ****
  682. --- 902,910 ----
  683.     /* Read the symbols, and put the interesting ones (sorted) in SYMS.  */
  684.     ck_fseek (fp, syms_offset, 0);
  685.     read_syms (fp, syms_size / sizeof (struct nlist));
  686. + 
  687. + #ifdef atarist
  688. +   }
  689.   #endif /* atarist */
  690.   
  691.     ck_fclose (fp);
  692. ***************
  693. *** 987,993 ****
  694.     return(0);
  695.   }
  696.   
  697. - #ifndef atarist
  698.   /* Read various information from the header of an object file.
  699.      Return 0 for failure or 1 for success.  */
  700.   
  701. --- 989,994 ----
  702. ***************
  703. *** 1062,1068 ****
  704.   
  705.     return 0;
  706.   }
  707. ! #endif /* !atarist */
  708.   
  709.   /* Output a summary gmon file containing all our accumulated
  710.      histogram and call-graph data.  */
  711. --- 1063,1092 ----
  712.   
  713.     return 0;
  714.   }
  715. ! 
  716. ! #ifdef atarist
  717. ! int
  718. ! atari_read_header_info (name, fp, syms_offset, syms_size)
  719. !      char *name;
  720. !      FILE *fp;
  721. !      long int *syms_offset;
  722. !      unsigned int *syms_size;
  723. ! {
  724. !   struct aexec hdr;
  725. ! 
  726. !   ck_fseek (fp, 0L, 0);
  727. ! 
  728. !   if (fread ((char *) &hdr, sizeof hdr, 1, fp) == 1 && !A_BADMAG(hdr))
  729. !     {
  730. !       *syms_offset = A_SYMOFF (hdr);
  731. !       *syms_size = hdr.a_syms;
  732. !       return 1;
  733. !     }
  734. ! 
  735. !   return 0;
  736. ! }
  737. ! 
  738. ! #endif /* atarist */
  739.   
  740.   /* Output a summary gmon file containing all our accumulated
  741.      histogram and call-graph data.  */
  742. ***************
  743. *** 1718,1724 ****
  744.   #ifndef atarist
  745.         if (!strcmp (p->name, filters[n].name)) {
  746.   #else
  747. !       if (!strncmp (p->name, filters[n].name, max_atari_sym_length)) {
  748.   #endif
  749.           tothist-=p->histo;
  750.           break;
  751. --- 1742,1750 ----
  752.   #ifndef atarist
  753.         if (!strcmp (p->name, filters[n].name)) {
  754.   #else
  755. !       if (atari_exec_format
  756. !           ? !strncmp (p->name, filters[n].name, max_atari_sym_length)
  757. !           : !strcmp (p->name, filters[n].name)) {
  758.   #endif
  759.           tothist-=p->histo;
  760.           break;
  761. ***************
  762. *** 2090,2097 ****
  763.     return 0;
  764.   }
  765.   
  766. - #ifndef atarist /* atarist specific version at end */
  767. - 
  768.   /* Read symbols from a.out file open on FP.  There are N of them.  Allocate a
  769.      vector to store the interesting ones in, and sort it numerically.  */
  770.   
  771. --- 2116,2121 ----
  772. ***************
  773. *** 2130,2135 ****
  774. --- 2154,2165 ----
  775.     for (sym= &tmpsyms[0], i=0; sym<&tmpsyms[n]; sym++) {
  776.       if (!badsym (sym)) {
  777.         syms[i].name=sym->n_un.n_name;
  778. + 
  779. + #ifndef nounderscore
  780. +       /* Remove the initial _ from the symbol name */
  781. +       if (*(syms[i].name)=='_')
  782. +     syms[i].name++;
  783. + #endif
  784.         syms[i].value=sym->n_value;
  785.         i++;
  786.       }
  787. ***************
  788. *** 2144,2149 ****
  789. --- 2174,2253 ----
  790.     qsort (syms, nsym, sizeof (struct mesym), symcmp);
  791.     free ((void *)tmpsyms);
  792.   }
  793. + 
  794. + #ifdef atarist
  795. + 
  796. + void
  797. + atari_read_syms FUN2(FILE *, fp, int, n)
  798. + {
  799. +   struct asym *tmpsyms;
  800. +   struct asym *sym;
  801. +   char *s, *p, *q;
  802. +   int i, j, is_long;
  803. + 
  804. +   /* creat space for incore name strings */
  805. +   s = strs = ck_malloc (n*sizeof (struct asym)); /* slight overkill */
  806. +   *s++ = 0;            /* so that sym.name[-1] is always defined */
  807. + 
  808. +   /* Read the entire symbol table.  */
  809. +   tmpsyms=(struct asym *)ck_malloc (n*sizeof (struct asym));
  810. +   ck_fread (tmpsyms, sizeof (struct asym), n, fp);
  811. + 
  812. +   /* Count the useful symbols.
  813. +      Also relocate their name-fields to be C string pointers.  */
  814. +   for (sym= &tmpsyms[0], i=0; sym<&tmpsyms[n]; sym++) {
  815. +     q = s;
  816. +     for (j = 0, p = sym->n_un.a_name; (j < 8) && (*p != '\0'); j++) 
  817. +       *s++ = *p++;
  818. +     if ((sym->a_type & A_LNAM) == A_LNAM) {
  819. +       max_atari_sym_length = 21;
  820. +       is_long = TRUE;
  821. +       if (sym + 1 < &tmpsyms[n]) {
  822. +     for (j = 0, p = sym[1].n_un.a_name; j < 14 && *p != '\0'; j++)
  823. +       *s++ = *p++;
  824. +       }
  825. +       else
  826. +     /* there's something wrong; assume short symbol */
  827. +     is_long = FALSE;
  828. +     }
  829. +     else
  830. +       is_long = FALSE;
  831. +     *s++ = '\0';
  832. +     sym->n_un.ptr = q;
  833. +     if (atari_badsym (sym))
  834. +       sym->n_un.ptr = NULL;
  835. +     else
  836. +       i++;
  837. +     if (is_long)
  838. +       /* skip symbol name extension */
  839. +       (++sym)->n_un.ptr = NULL;
  840. +   }
  841. + 
  842. +   /* Allocate permanent space and copy useful symbols into it.  */
  843. +   nsym=i;
  844. +   syms=(struct mesym *)ck_calloc (nsym, sizeof (struct mesym));
  845. + 
  846. +   for (sym= &tmpsyms[0], i=0; sym<&tmpsyms[n]; sym++) {
  847. +     if (sym->n_un.ptr != NULL) {
  848. +       syms[i].name=sym->n_un.ptr;
  849. + 
  850. + #ifndef nounderscore
  851. +       /* Remove the initial _ from the symbol name */
  852. +       if (*(syms[i].name)=='_')
  853. +     syms[i].name++;
  854. + #endif
  855. +       syms[i].value=sym->a_value;
  856. +       i++;
  857. +     }
  858. +   }
  859. + 
  860. +   if (i != nsym)
  861. +     exit (96);
  862. + 
  863. +   /* Put symbols in numeric order.  */
  864. +   qsort (syms, nsym, sizeof (struct mesym), symcmp);
  865. +   free ((void *)tmpsyms);
  866. + }
  867.   #endif /* atarist */
  868.   
  869.   /* Return the symbol which has the largest value less than or equal to VAL.
  870. ***************
  871. *** 2177,2183 ****
  872.     return m;
  873.   }
  874.   
  875. - #ifndef atarist
  876.   /* Return TRUE if the nlist-entry SYM describes a symbol
  877.      that gprof should NOT pay attention to.  */
  878.   
  879. --- 2281,2286 ----
  880. ***************
  881. *** 2193,2199 ****
  882.       return TRUE;
  883.   #endif
  884.     local = !(sym->n_type&N_EXT);
  885. !   if (no_locals && !local)
  886.       return TRUE;
  887.     /* Filenames or pascal labels should be ignored */
  888.   if (local
  889. --- 2296,2302 ----
  890.       return TRUE;
  891.   #endif
  892.     local = !(sym->n_type&N_EXT);
  893. !   if (no_locals && local)
  894.       return TRUE;
  895.     /* Filenames or pascal labels should be ignored */
  896.   if (local
  897. ***************
  898. *** 2206,2212 ****
  899. --- 2309,2342 ----
  900.       return TRUE;
  901.     return FALSE;
  902.   }
  903. + 
  904. + #ifdef atarist
  905. + 
  906. + /* Return TRUE if the asym-entry SYM describes a symbol
  907. +    that gprof should NOT pay attention to.  */
  908. + 
  909. + int
  910. + atari_badsym FUN1(struct asym *, sym)
  911. + {
  912. +   int local;
  913. +   if (!(sym->a_type & A_TEXT))
  914. +     return TRUE;
  915. +   local = !(sym->a_type & A_GLOBL);
  916. +   if (no_locals && local)
  917. +     return TRUE;
  918. +   /* Filenames or pascal labels should be ignored */
  919. +   if (local
  920. +       && (index (sym->n_un.ptr, '.') || index (sym->n_un.ptr, '$')
  921. +       || index (sym->n_un.ptr, '/') || index (sym->n_un.ptr, '\\')
  922. +       || index (sym->n_un.ptr, ':')
  923. + #ifndef nounderscore
  924. +       || sym->n_un.ptr[0] != '_'
  925.   #endif
  926. +       ))
  927. +     return TRUE;
  928. +   return FALSE;
  929. + }
  930. + #endif /* atarist */
  931.   
  932.   /* This is used to qsort () the symbol table into numerical order. */
  933.   
  934. ***************
  935. *** 2829,2846 ****
  936.   
  937.     n=0;
  938.     for (np=syms, endp= &syms[nsym]; np<endp; np++) {
  939. -   char *demangled = cplus_demangle (np->name);
  940. -   char *name;
  941. - 
  942. -     if (demangled)
  943. -       name = demangled;
  944. -     else {
  945. -       name = np->name;
  946.   #ifndef nounderscore
  947. !       if (*name == '_')
  948. !     name++;
  949.   #endif
  950. !     }
  951.       
  952.       sprintf (buf, "%-15s %#6lx %d %2d.%2d[%d]",
  953.            name, np->value, np->histo, np->ncalled, np->ncalls, np->cycnum);
  954. --- 2959,2971 ----
  955.   
  956.     n=0;
  957.     for (np=syms, endp= &syms[nsym]; np<endp; np++) {
  958.   #ifndef nounderscore
  959. !     char *demangled = cplus_demangle (np->name);
  960. ! #else
  961. !     char *demangled =
  962. !       cplus_demangle (np->name[-1] == '_' ? np->name-1 : np->name);
  963.   #endif
  964. !     char *name = demangled == NULL ? np->name : demangled;
  965.       
  966.       sprintf (buf, "%-15s %#6lx %d %2d.%2d[%d]",
  967.            name, np->value, np->histo, np->ncalled, np->ncalls, np->cycnum);
  968. ***************
  969. *** 2877,2991 ****
  970.     }
  971.   }
  972.   
  973. - #ifdef atarist    /* atariSt specific versions */
  974. - 
  975. - /* Return TRUE if the asym-entry SYM describes a symbol
  976. -    that gprof should NOT pay attention to.  */
  977. - 
  978. - #define ISDRIVE(d) ( \
  979. -     (((d) >= 'A') && ((d) <= 'Z')) || \
  980. -         (((d) >= 'a') && ((d) <= 'z'))    )
  981. - int
  982. - badsym FUN1(struct asym *, sym)
  983. - {
  984. -   if(sym->a_type == A_UNDF)
  985. -     return TRUE;  /* these are the symbols ld (write_atari_sym()) had faked */
  986. -   if (!(sym->a_type & A_TEXT))
  987. -     return TRUE;
  988. -   if (no_locals && !(sym->a_type & A_GLOBL))
  989. -     return TRUE;
  990. -   if(!strncmp(sym->n_un.ptr, "gcc_comp", 8L))
  991. -     return TRUE;
  992. -   if(ISDRIVE((sym->n_un.ptr)[0]) && ((sym->n_un.ptr)[1] == ':'))
  993. -    return TRUE;
  994. -   /* Filenames or pascal labels should be ignored */
  995. -   if (index (sym->n_un.ptr, '.') || index (sym->n_un.ptr, '$') ||
  996. -       index (sym->n_un.ptr, '/') || index (sym->n_un.ptr, '\\')  )
  997. -     return TRUE;
  998. -   return FALSE;
  999. - }
  1000. - 
  1001. - /* Read symbols from a.out file open on FP.  There are N of them.  Allocate a
  1002. -    vector to store the interesting ones in, and sort it numerically.  */
  1003. - 
  1004. - void
  1005. - read_syms FUN2(FILE *, fp, int, n)
  1006. - {
  1007. -   struct asym *tmpsyms;
  1008. -   char *s, *p, *q;
  1009. -   int i,j,is_long;
  1010. -   
  1011. -   /* creat space for incore name strings */
  1012. -   s = strs = ck_malloc(n*25); /* slight overkill */
  1013. - 
  1014. -   /* Read the entire symbol table.  */
  1015. -   tmpsyms=(struct asym *)ck_malloc (n*sizeof (struct asym));
  1016. -   ck_fread (tmpsyms, sizeof (struct asym), n, fp);
  1017. - 
  1018. -    
  1019. -   /* Count the useful symbols.
  1020. -      Also relocate their name-fields to be C string pointers.  */
  1021. -   for(nsym = 0, i = 0; i < n; i++)
  1022. -   {
  1023. -       for(j = 0, p = &(tmpsyms[i].n_un.a_name[0]), q = s;
  1024. -       (j < 8) && (*p != '\0'); j++) 
  1025. -       *s++ = *p++;
  1026. -       if ((tmpsyms[i].a_type & A_LNAM) == A_LNAM)
  1027. -     {
  1028. -       max_atari_sym_length = 22;
  1029. -       is_long = TRUE;
  1030. -       if (i + 1 < n)
  1031. -         for (j = 0, p = &tmpsyms[i+1].n_un.a_name[0];
  1032. -          j < 14 && *p != '\0'; j++)
  1033. -           *s++ = *p++;
  1034. -       else
  1035. -         /* there's something wrong; assume short symbol */
  1036. -         is_long = FALSE;
  1037. -     }
  1038. -       else
  1039. -     is_long = FALSE;
  1040. -       *s++ = '\0';
  1041. -       tmpsyms[i].n_un.ptr = q;
  1042. -       if (badsym (&tmpsyms[i]))
  1043. -       {
  1044. -       tmpsyms[i].n_un.ptr = (char *)0;
  1045. -       }
  1046. -       else
  1047. -       {
  1048. -       nsym++;
  1049. -       }
  1050. -       if (is_long)
  1051. -     /* skip symbol name extension */
  1052. -     tmpsyms[++i].n_un.ptr = NULL;
  1053. -   }
  1054. -   
  1055. -   /* Allocate permanent space and copy useful symbols into it.  */
  1056. -   syms=(struct mesym *)ck_calloc (nsym, sizeof (struct mesym));
  1057. - 
  1058. -   for (i=0, j = 0; i < n; i++) {
  1059. -     if (tmpsyms[i].n_un.ptr != (char *)0) {
  1060. -       syms[j].name = tmpsyms[i].n_un.ptr;
  1061. - /* #ifndef nounderscore */
  1062. - #if 0
  1063. -       /* Remove the initial _ from the symbol name */
  1064. -       if (*(syms[j].name)=='_')
  1065. -     syms[j].name++;
  1066. - #endif
  1067. -       syms[j].value = tmpsyms[i].a_value;
  1068. -       j++;
  1069. -     }
  1070. -   }
  1071. - 
  1072. -   if (j != nsym)
  1073. -     exit (99);
  1074. - 
  1075. -   free ((void *)tmpsyms);
  1076. - 
  1077. -   /* Put symbols in numeric order.  */
  1078. -   qsort (syms, nsym, sizeof (struct mesym), symcmp);
  1079. - }
  1080. - #endif /* atarist */
  1081. - 
  1082.   void print_version FUN0()
  1083.   {
  1084.   #ifdef atarist
  1085. --- 3002,3007 ----
  1086. ***************
  1087. *** 3018,3046 ****
  1088.   void
  1089.   fprint_name FUN2(FILE *, stream, char *, name)
  1090.   {
  1091.     char *demangled = cplus_demangle (name);
  1092. !   if (demangled == NULL)
  1093. !   {
  1094. ! #ifndef nounderscore
  1095. !       if (*name == '_')
  1096. !     name++;
  1097.   #endif
  1098. !       fputs (name, stream);
  1099. !   }
  1100.     else
  1101.       {
  1102.         fputs (demangled, stream);
  1103.         free (demangled);
  1104.       }
  1105.   }
  1106. - 
  1107. - #if 0
  1108. - /* let this be dummy for now, 
  1109. -    if you want to throw in the cplusplus name demangler, simple
  1110. -    delete this function, and link with cplus-dem.o
  1111. - */
  1112. - char *cplus_demangle FUN1(char *, name)
  1113. - {
  1114. -   return NULL;
  1115. - }
  1116. - #endif
  1117. --- 3034,3049 ----
  1118.   void
  1119.   fprint_name FUN2(FILE *, stream, char *, name)
  1120.   {
  1121. + #ifdef nounderscore
  1122.     char *demangled = cplus_demangle (name);
  1123. ! #else
  1124. !   char *demangled = cplus_demangle (name[-1] == '_' ? name-1 : name);
  1125.   #endif
  1126. !   if (demangled == NULL)
  1127. !     fputs (name, stream);
  1128.     else
  1129.       {
  1130.         fputs (demangled, stream);
  1131.         free (demangled);
  1132.       }
  1133.   }
  1134.